home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / tabnanny.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  8KB  |  279 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''The Tab Nanny despises ambiguous indentation.  She knows no mercy.
  5.  
  6. tabnanny -- Detection of ambiguous indentation
  7.  
  8. For the time being this module is intended to be called as a script.
  9. However it is possible to import it into an IDE and use the function
  10. check() described below.
  11.  
  12. Warning: The API provided by this module is likely to change in future
  13. releases; such changes may not be backward compatible.
  14. '''
  15. __version__ = '6'
  16. import os
  17. import sys
  18. import getopt
  19. import tokenize
  20. if not hasattr(tokenize, 'NL'):
  21.     raise ValueError("tokenize.NL doesn't exist -- tokenize module too old")
  22.  
  23. __all__ = [
  24.     'check',
  25.     'NannyNag',
  26.     'process_tokens']
  27. verbose = 0
  28. filename_only = 0
  29.  
  30. def errprint(*args):
  31.     sep = ''
  32.     for arg in args:
  33.         sys.stderr.write(sep + str(arg))
  34.         sep = ' '
  35.     
  36.     sys.stderr.write('\n')
  37.  
  38.  
  39. def main():
  40.     global filename_only, verbose
  41.     
  42.     try:
  43.         (opts, args) = getopt.getopt(sys.argv[1:], 'qv')
  44.     except getopt.error:
  45.         msg = None
  46.         errprint(msg)
  47.         return None
  48.  
  49.     for o, a in opts:
  50.         if o == '-q':
  51.             filename_only = filename_only + 1
  52.         
  53.         if o == '-v':
  54.             verbose = verbose + 1
  55.             continue
  56.     
  57.     if not args:
  58.         errprint('Usage:', sys.argv[0], '[-v] file_or_directory ...')
  59.         return None
  60.     
  61.     for arg in args:
  62.         check(arg)
  63.     
  64.  
  65.  
  66. class NannyNag(Exception):
  67.     '''
  68.     Raised by tokeneater() if detecting an ambiguous indent.
  69.     Captured and handled in check().
  70.     '''
  71.     
  72.     def __init__(self, lineno, msg, line):
  73.         self.lineno = lineno
  74.         self.msg = msg
  75.         self.line = line
  76.  
  77.     
  78.     def get_lineno(self):
  79.         return self.lineno
  80.  
  81.     
  82.     def get_msg(self):
  83.         return self.msg
  84.  
  85.     
  86.     def get_line(self):
  87.         return self.line
  88.  
  89.  
  90.  
  91. def check(file):
  92.     '''check(file_or_dir)
  93.  
  94.     If file_or_dir is a directory and not a symbolic link, then recursively
  95.     descend the directory tree named by file_or_dir, checking all .py files
  96.     along the way. If file_or_dir is an ordinary Python source file, it is
  97.     checked for whitespace related problems. The diagnostic messages are
  98.     written to standard output using the print statement.
  99.     '''
  100.     if os.path.isdir(file) and not os.path.islink(file):
  101.         if verbose:
  102.             print '%r: listing directory' % (file,)
  103.         
  104.         names = os.listdir(file)
  105.         for name in names:
  106.             fullname = os.path.join(file, name)
  107.             if os.path.isdir(fullname) or not os.path.islink(fullname) or os.path.normcase(name[-3:]) == '.py':
  108.                 check(fullname)
  109.                 continue
  110.         
  111.         return None
  112.     
  113.     
  114.     try:
  115.         f = open(file)
  116.     except IOError:
  117.         msg = None
  118.         errprint('%r: I/O Error: %s' % (file, msg))
  119.         return None
  120.  
  121.     if verbose > 1:
  122.         print 'checking %r ...' % file
  123.     
  124.     
  125.     try:
  126.         process_tokens(tokenize.generate_tokens(f.readline))
  127.     except tokenize.TokenError:
  128.         msg = None
  129.         errprint('%r: Token Error: %s' % (file, msg))
  130.         return None
  131.     except NannyNag:
  132.         nag = None
  133.         badline = nag.get_lineno()
  134.         line = nag.get_line()
  135.         if verbose:
  136.             print '%r: *** Line %d: trouble in tab city! ***' % (file, badline)
  137.             print 'offending line: %r' % (line,)
  138.             print nag.get_msg()
  139.         elif ' ' in file:
  140.             file = '"' + file + '"'
  141.         
  142.         if filename_only:
  143.             print file
  144.         else:
  145.             print file, badline, repr(line)
  146.         return None
  147.  
  148.     if verbose:
  149.         print '%r: Clean bill of health.' % (file,)
  150.     
  151.  
  152.  
  153. class Whitespace:
  154.     (S, T) = ' \t'
  155.     
  156.     def __init__(self, ws):
  157.         self.raw = ws
  158.         S = Whitespace.S
  159.         T = Whitespace.T
  160.         count = []
  161.         b = n = nt = 0
  162.         for ch in self.raw:
  163.             if ch == S:
  164.                 n = n + 1
  165.                 b = b + 1
  166.                 continue
  167.             if ch == T:
  168.                 n = n + 1
  169.                 nt = nt + 1
  170.                 if b >= len(count):
  171.                     count = count + [
  172.                         0] * ((b - len(count)) + 1)
  173.                 
  174.                 count[b] = count[b] + 1
  175.                 b = 0
  176.                 continue
  177.             break
  178.         
  179.         self.n = n
  180.         self.nt = nt
  181.         self.norm = (tuple(count), b)
  182.         self.is_simple = len(count) <= 1
  183.  
  184.     
  185.     def longest_run_of_spaces(self):
  186.         (count, trailing) = self.norm
  187.         return max(len(count) - 1, trailing)
  188.  
  189.     
  190.     def indent_level(self, tabsize):
  191.         (count, trailing) = self.norm
  192.         il = 0
  193.         for i in range(tabsize, len(count)):
  194.             il = il + (i / tabsize) * count[i]
  195.         
  196.         return trailing + tabsize * (il + self.nt)
  197.  
  198.     
  199.     def equal(self, other):
  200.         return self.norm == other.norm
  201.  
  202.     
  203.     def not_equal_witness(self, other):
  204.         n = max(self.longest_run_of_spaces(), other.longest_run_of_spaces()) + 1
  205.         a = []
  206.         for ts in range(1, n + 1):
  207.             if self.indent_level(ts) != other.indent_level(ts):
  208.                 a.append((ts, self.indent_level(ts), other.indent_level(ts)))
  209.                 continue
  210.         
  211.         return a
  212.  
  213.     
  214.     def less(self, other):
  215.         if self.n >= other.n:
  216.             return False
  217.         
  218.         if self.is_simple and other.is_simple:
  219.             return self.nt <= other.nt
  220.         
  221.         n = max(self.longest_run_of_spaces(), other.longest_run_of_spaces()) + 1
  222.         for ts in range(2, n + 1):
  223.             if self.indent_level(ts) >= other.indent_level(ts):
  224.                 return False
  225.                 continue
  226.         
  227.         return True
  228.  
  229.     
  230.     def not_less_witness(self, other):
  231.         n = max(self.longest_run_of_spaces(), other.longest_run_of_spaces()) + 1
  232.         a = []
  233.         for ts in range(1, n + 1):
  234.             if self.indent_level(ts) >= other.indent_level(ts):
  235.                 a.append((ts, self.indent_level(ts), other.indent_level(ts)))
  236.                 continue
  237.         
  238.         return a
  239.  
  240.  
  241.  
  242. def format_witnesses(w):
  243.     firsts = map((lambda tup: str(tup[0])), w)
  244.     prefix = 'at tab size'
  245.     if len(w) > 1:
  246.         prefix = prefix + 's'
  247.     
  248.     return prefix + ' ' + ', '.join(firsts)
  249.  
  250.  
  251. def process_tokens(tokens):
  252.     INDENT = tokenize.INDENT
  253.     DEDENT = tokenize.DEDENT
  254.     NEWLINE = tokenize.NEWLINE
  255.     JUNK = (tokenize.COMMENT, tokenize.NL)
  256.     indents = [
  257.         Whitespace('')]
  258.     check_equal = 0
  259.     for type, token, start, end, line in tokens:
  260.         if type == NEWLINE:
  261.             check_equal = 1
  262.             continue
  263.         if type == INDENT:
  264.             check_equal = 0
  265.             thisguy = Whitespace(token)
  266.             if not indents[-1].less(thisguy):
  267.                 witness = indents[-1].not_less_witness(thisguy)
  268.                 msg = 'indent not greater e.g. ' + format_witnesses(witness)
  269.                 raise NannyNag(start[0], msg, line)
  270.             
  271.             indents.append(thisguy)
  272.             continue
  273.         None if type == DEDENT else indents[-1].equal(thisguy)
  274.     
  275.  
  276. if __name__ == '__main__':
  277.     main()
  278.  
  279.